// 修复图层配置 - 使用数字键匹配传入的type
export const layerConfigs = {
  1: { name: '标准地图' },
  2: { name: '卫星地图-天地图' },
  3: { name: '卫星地图-百度' },
};
// 计算整数化倍数：
export const integerOperation = (val1: number, val2: number) => {
  const val1DecimalIndex = val1.toString().indexOf('.'); // 获取数值1的小数位的长度
  const len1 =
    val1DecimalIndex === -1 ? 0 : val1.toString().length - val1DecimalIndex - 1;
  const val2DecimalIndex = val2.toString().indexOf('.'); // 获取数值2的小数位的长度
  const len2 =
    val2DecimalIndex === -1 ? 0 : val2.toString().length - val2DecimalIndex - 1;
  const p = Math.max(len1, len2); // 获取大的小数位数
  // 避免最终求出结果的长度大于最大长度的时候导致精度丢失 开启下面
  // p += p - Math.min(len1, len2);
  return Math.pow(10, p); // Math.pow() 计算一个数的指定次幂的方法 10的p次方
};
// 解决浮点数运算的精度
export const arithmetic = {
  add(val1: number, val2: number) {
    const p = integerOperation(val1, val2);
    return (val1 * p + val2 * p) / p;
  },
  subtract(val1: number, val2: number) {
    const p = integerOperation(val1, val2);
    return (val1 * p - val2 * p) / p;
  },
  multiply(val1: number, val2: number) {
    const p = integerOperation(val1, val2);
    return (val1 * p * (val2 * p)) / (p * p);
  },
  division(val1: number, val2: number) {
    const p = integerOperation(val1, val2);
    return (val1 * p) / (val2 * p) / (p * p);
  },
};
// 根据高度模式设置默认高度
export const setDefaultHeightByMode = (value: string) => {
  switch (value) {
    case '0': // 海拔高度
      return 300; // 海拔200米
      break;
    case '1': // 相对地面高度
      return 200; // 相对地面100米
      break;
    case '2': // 相对地形高度
      return 250; // 相对地形150米
      break;
    default:
      return 300; // 默认海拔高度
  }
};
// 获取旧的高度模式对应的默认高度
export const getOldDefaultHeight = (oldMode: string) => {
  switch (oldMode) {
    case '0':
      return 300;
    case '1':
      return 200;
    case '2':
      return 250;
    default:
      return 300;
  }
};

// 判断面是否自相交的函数
export const isPolygonSelfIntersecting = (AMap: any, points: any) => {
  const segments = [];
  // 将面分解为线段
  for (let i = 0; i < points.length; i++) {
    const p1 = points[i];
    const p2 = points[(i + 1) % points.length];
    segments.push([p1, p2]);
  }

  // 检查任意两条线段是否相交
  for (let i = 0; i < segments.length; i++) {
    for (let j = i + 2; j < segments.length; j++) {
      // 跳过相邻的线段（它们共享一个点）
      if (j === segments.length - 1 && i === 0) continue;

      const [p1, p2] = segments[i];
      const [p3, p4] = segments[j];

      if (AMap.GeometryUtil.doesSegmentsIntersect(p1, p2, p3, p4)) {
        return true; // 发现自相交
      }
    }
  }

  return false; // 没有自相交
};

// 通用去重函数
// 使用示例：
// 1. 基本用法（经纬度对象）
// const uniqueData = removeDuplicates(allData.value, { precision: 6 });
//
// 2. 自定义键生成函数
// const uniqueData = removeDuplicates(data, {
//   keyGenerator: (item) => `${item.id}_${item.name}`,
//   logPrefix: "自定义去重"
// });
//
// 3. 带移除回调的去重
// const uniqueData = removeDuplicates(markers, {
//   onRemove: (marker) => map.value.remove(marker),
//   logPrefix: "清理marker"
// });
export const removeDuplicates = (data: any, options: any = {}) => {
  const {
    precision = 6, // 精度位数
    keyGenerator = null, // 自定义键生成函数
    onRemove = null, // 移除重复项时的回调
  } = options;

  if (!data || data.length === 0) {
    return data;
  }

  const originalLength = data.length;
  const uniqueData = [];
  const seenKeys = new Set();

  data.forEach((item, index) => {
    let key;

    if (keyGenerator) {
      // 使用自定义键生成函数
      key = keyGenerator(item);
    } else if (item.lng !== undefined && item.lat !== undefined) {
      // 默认处理经纬度对象
      key = `${item.lng.toFixed(precision)}_${item.lat.toFixed(precision)}`;
    } else if (item.getPosition) {
      // 处理有getPosition方法的对象（如marker）
      const position = item.getPosition();
      key = `${position.lng.toFixed(precision)}_${position.lat.toFixed(precision)}`;
    } else {
      // 处理普通对象，使用JSON字符串作为键
      key = JSON.stringify(item);
    }

    if (!seenKeys.has(key)) {
      seenKeys.add(key);
      uniqueData.push(item);
    } else if (onRemove) {
      // 调用移除回调函数
      onRemove(item, index);
    }
  });
  const finalLength = uniqueData.length;
  return uniqueData;
};

// 通用的数值调整函数
export const adjustValue = (
  value: number,
  change: number,
  min: number,
  max: number,
) => {
  const newValue = parseFloat((value + change).toFixed(2));
  return Math.max(min, Math.min(max, newValue));
};
